package com.quanyan.stadium.component.task;

import com.github.ltsopensource.core.domain.Job;
import com.github.ltsopensource.jobclient.JobClient;
import com.github.ltsopensource.jobclient.domain.Response;
import com.quanyan.stadium.constants.GameConstants;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;

/**
 * @Since 2016-07-04
 */
public class TimerTaskJob {

    private Logger logger = Logger.getLogger(TimerTaskJob.class);

    @Autowired
    private JobClient jobClient;

    @Value("${lts.node.name}")
    private String ltsNodeName;

    SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public void executeTask() {
        // 运动场定时扫描关闭订单
        /*Job closeExpireOrderJob = new Job();
        closeExpireOrderJob.setTaskId(GameConstants.STADIUM_JOB_ID_CLOSE_ORDER);
        closeExpireOrderJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        closeExpireOrderJob.setNeedFeedback(true);
        closeExpireOrderJob.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        closeExpireOrderJob.setRepeatCount(-1);             // 无限循环
        closeExpireOrderJob.setRepeatInterval(5 * 60 * 1000L);  // 5分钟 执行一次
        Response closeExpireOrderJobResponse = jobClient.submitJob(closeExpireOrderJob);
        logger.warn("自动回收不合法订单，返回结果: " + closeExpireOrderJobResponse);*/

        // 官方赛事分数排名记
        /*Job officialGameEventCollectJob = new Job();
        officialGameEventCollectJob.setTaskId(GameConstants.STADIUM_JOB_ID_REFRESH_OFFICIAL_GAME);
        officialGameEventCollectJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        officialGameEventCollectJob.setNeedFeedback(true);
        officialGameEventCollectJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        officialGameEventCollectJob.setRepeatCount(-1);  //无限循环
        officialGameEventCollectJob.setRepeatInterval(3 * 60 * 1000L); //3分钟 执行一次
        Response officialGameEventCollectJobResponse = jobClient.submitJob(officialGameEventCollectJob);
        logger.warn("官方赛事分数排记录统计，返回结果: " + officialGameEventCollectJobResponse);*/

        //每隔3分钟 自动刷新检测处于退位阶段的赛事
        /*Job complementeOfficialGameEventCollectJob = new Job();
        complementeOfficialGameEventCollectJob.setTaskId(GameConstants.STADIUM_JOB_ID_REFRESH_COMPLEMENTE_OFFICIAL_GAME);
        complementeOfficialGameEventCollectJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        complementeOfficialGameEventCollectJob.setNeedFeedback(true);
        complementeOfficialGameEventCollectJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        complementeOfficialGameEventCollectJob.setRepeatCount(-1);  //无限循环
        complementeOfficialGameEventCollectJob.setRepeatInterval(5 * 60 * 1000L);  // 5分钟 执行一次
        Response complementeOfficialGameEventCollectJobResponse = jobClient.submitJob(complementeOfficialGameEventCollectJob);
        logger.warn("自动刷新检测处于退位阶段的赛事，返回结果: " + complementeOfficialGameEventCollectJobResponse);*/

        //每天凌晨2点,定时刷新比赛数量
        Job updateGameNumJob = new Job();
        updateGameNumJob.setTaskId(GameConstants.STADIUM_JOB_ID_REFRESH_GAME_EVENT_NUM);
        updateGameNumJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        updateGameNumJob.setNeedFeedback(true);
        updateGameNumJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        updateGameNumJob.setRepeatCount(-1);  //无限循环
        updateGameNumJob.setCronExpression("0 0 2 * * ?");  // 每天凌晨2点
        Response updateGameNumJobResponse = jobClient.submitJob(updateGameNumJob);
        logger.warn("定时刷新比赛数量，返回结果: " + updateGameNumJobResponse);

        //刷新个人积分数据,610分钟刷新一次,即更新10小时多一点的
        Job updateUserScore = new Job();
        updateUserScore.setTaskId(GameConstants.STADIUM_JOB_ID_REFRESH_USER_SCORE);
        updateUserScore.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        updateUserScore.setNeedFeedback(true);
        updateUserScore.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        updateUserScore.setRepeatCount(-1);  //无限循环
        updateUserScore.setCronExpression("0 0 6,14,22 * * ?");  // 6.14.22点开始执行
        Response updateUserScoreResponse = jobClient.submitJob(updateUserScore);
        logger.warn("刷新个人积分数据，返回结果: " + updateUserScoreResponse);

        //用户报名比赛开始通知, 应该5分钟刷新一次, 比赛前1小时开始开始推送
        Job gameStartOneHourJob = new Job();
        gameStartOneHourJob.setTaskId(GameConstants.STADIUM_JOB_ID_GAME_START_REMIND_1_HOUR);
        gameStartOneHourJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        gameStartOneHourJob.setNeedFeedback(true);
        gameStartOneHourJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        gameStartOneHourJob.setRepeatCount(-1);  //无限循环
        gameStartOneHourJob.setRepeatInterval(5 * 60 * 1000L);  // 5分钟 执行一次
        Response gameStartOneHourJobResponse = jobClient.submitJob(gameStartOneHourJob);
        logger.warn("用户报名比赛前一小时开始通知，返回结果: " + gameStartOneHourJobResponse);

        //用户报名比赛开始通知, 应该10分钟刷新一次, 比赛开始开始推送
        Job gameStartJob = new Job();
        gameStartJob.setTaskId(GameConstants.STADIUM_JOB_ID_GAME_START_REMIND_0_HOUR);
        gameStartJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        gameStartJob.setNeedFeedback(true);
        gameStartJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        gameStartJob.setRepeatCount(-1);  //无限循环
        gameStartJob.setRepeatInterval(10 * 60 * 1000L);  // 10分钟 执行一次
        Response gameStartJobResponse = jobClient.submitJob(gameStartJob);
        logger.warn("用户报名比赛开始通知，返回结果: " + gameStartJobResponse);


        //mq异常处理, 应该3分钟刷新一次
        Job exceptionMQJob = new Job();
        exceptionMQJob.setTaskId(GameConstants.STADIUM_JOB_ID_REFRESH_EXCEPTION_MQ);
        exceptionMQJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        exceptionMQJob.setNeedFeedback(true);
        exceptionMQJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        exceptionMQJob.setRepeatCount(-1);  //无限循环
        exceptionMQJob.setRepeatInterval(3 * 60 * 1000L);  // 3分钟 执行一次
        Response exceptionMQResponse = jobClient.submitJob(exceptionMQJob);
        logger.warn("mq异常处理，返回结果: " + exceptionMQResponse);


        //邀请次数每天凌晨恢复
        Job updateInviteCountJob = new Job();
        updateInviteCountJob.setTaskId(GameConstants.STADIUM_JOB_ID_REFRESH_INVITE_COUNT);
        updateInviteCountJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        updateInviteCountJob.setNeedFeedback(true);
        updateInviteCountJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        updateInviteCountJob.setRepeatCount(-1);  //无限循环
        updateInviteCountJob.setCronExpression("0 0 0 * * ?");  // 每天凌晨处理
        Response updateInviteCountJobResponse = jobClient.submitJob(updateInviteCountJob);
        logger.warn("邀请次数每天凌晨恢复，返回结果: " + updateInviteCountJobResponse);

        //更新个人对抗赛录入比分状态
        Job personPkRecordStatus = new Job();
        personPkRecordStatus.setTaskId(GameConstants.STADIUM_JOB_ID_UPDATE_PERSON_PK_RECORD);
        personPkRecordStatus.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        personPkRecordStatus.setNeedFeedback(true);
        personPkRecordStatus.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        personPkRecordStatus.setRepeatCount(-1);  //无限循环
        personPkRecordStatus.setCronExpression("0 0 0 * * ?");  // 每天凌晨处理
        Response personPkRecordResponse = jobClient.submitJob(personPkRecordStatus);
        logger.warn("查看个人对抗赛录入比分状态，返回结果: " + personPkRecordResponse);


        //关闭比赛开始未报名的比赛
        Job closePersonPkExpireStatus = new Job();
        closePersonPkExpireStatus.setTaskId(GameConstants.STADIUM_JOB_ID_CLOSE_PERSON_PK_EXPIRE);
        closePersonPkExpireStatus.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        closePersonPkExpireStatus.setNeedFeedback(true);
        closePersonPkExpireStatus.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        closePersonPkExpireStatus.setRepeatCount(-1);  //无限循环
        closePersonPkExpireStatus.setRepeatInterval(1 * 30* 60 * 1000L);  // 三十分钟 执行一次
        Response closePersonPkExpireResponse = jobClient.submitJob(closePersonPkExpireStatus);
        logger.warn("关闭比赛开始为报名的比赛，返回结果: " + closePersonPkExpireResponse);

    }

    /**
     * 提交一个定时任务，指定时间执行
     *
     * @param params      传递给业务执行类的参数
     * @param taskId      任务id
     * @param executeTime 执行时间点
     */
    public void submitTask(Map<String, String> params, String taskId,
                           long executeTime, long repeatInterval) {
        logger.warn("executeTime=" + sf.format(new Date(executeTime)) + ", repeatInterval=" + repeatInterval);
        Job job = new Job();
        job.setTaskId(taskId);
        job.setTaskTrackerNodeGroup("taskTracker_club");
        job.setNeedFeedback(true);
        job.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        job.setTriggerTime(executeTime);    //设置指定时间执行，在指定时间点触发
        if (params != null && params.size() > 0) {
            job.setExtParams(params);           //执行任务用到的参数
        }
        if (repeatInterval != 0) {
            job.setRepeatCount(-1); //无限循环
            job.setRepeatInterval(repeatInterval); //每间隔多久执行一次，单位秒
        }
        Response response = jobClient.submitJob(job);

        logger.warn("启动定时任务：" + taskId + ", 参数：" + params +
                ", 在" + sf.format(new Date(executeTime)) + "时执行！" + " 返回结果: " + response);
    }
}
